KBDLLHOOKSTRUCT *kbdhook,
GdkSurface *window)
{
- GdkSurface *toplevel = gdk_surface_get_toplevel (window);
+ GdkSurface *toplevel = window;
static DWORD last_keydown = 0;
if (message == WM_KEYDOWN &&
pt = msg->pt;
if (!grab->owner_events)
- event_surface = grab->native_surface;
+ event_surface = grab->surface;
else
{
event_surface = NULL;
event_surface = gdk_win32_handle_table_lookup (hwnd);
}
if (event_surface == NULL)
- event_surface = grab->native_surface;
+ event_surface = grab->surface;
}
/* need to also adjust the coordinates to the new window */
static void
show_window_recurse (GdkSurface *window, gboolean hide_window)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
GSList *children = impl->transient_children;
GdkSurface *child = NULL;
do_show_window (GdkSurface *window, gboolean hide_window)
{
GdkSurface *tmp_window = NULL;
- GdkSurfaceImplWin32 *tmp_impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *tmp_impl = GDK_WIN32_SURFACE (window);
if (!tmp_impl->changing_state)
{
while (tmp_impl->transient_owner != NULL)
{
tmp_window = tmp_impl->transient_owner;
- tmp_impl = GDK_SURFACE_IMPL_WIN32 (tmp_window->impl);
+ tmp_impl = GDK_WIN32_SURFACE (tmp_window);
}
/* If we couldn't find one, use the window provided. */
GdkDeviceGrabInfo *grab;
GdkDeviceManagerWin32 *device_manager;
POINT pt;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
device_manager = _gdk_device_manager;
mode != GDK_CROSSING_UNGRAB)
{
/* !owner_event => only report events wrt grab window, ignore rest */
- if ((GdkSurface *)window != grab->native_surface)
+ if ((GdkSurface *)window != grab->surface)
return;
}
_gdk_win32_append_event (event);
}
-static GdkSurface *
-get_native_parent (GdkSurface *window)
-{
- if (window->parent != NULL)
- return window->parent->impl_surface;
- return NULL;
-}
-
static GdkSurface *
find_common_ancestor (GdkSurface *win1,
GdkSurface *win2)
while (tmp != NULL)
{
path1 = g_list_prepend (path1, tmp);
- tmp = get_native_parent (tmp);
+ tmp = tmp->parent;
}
tmp = win2;
while (tmp != NULL)
{
path2 = g_list_prepend (path2, tmp);
- tmp = get_native_parent (tmp);
+ tmp = tmp->parent;
}
list1 = path1;
notify_type = GDK_NOTIFY_VIRTUAL;
last = a;
- win = get_native_parent (a);
+ win = a->parent;
while (win != c && win != NULL)
{
send_crossing_event (display,
mask, time_);
last = win;
- win = get_native_parent (win);
+ win = win->parent;
}
}
}
if (c != b)
{
path = NULL;
- win = get_native_parent (b);
+ win = b->parent;
while (win != c && win != NULL)
{
path = g_list_prepend (path, win);
- win = get_native_parent (win);
+ win = win->parent;
}
if (non_linear)
_gdk_win32_get_window_rect (GdkSurface *window,
RECT *rect)
{
- GdkSurfaceImplWin32 *surface_impl;
RECT client_rect;
POINT point;
HWND hwnd;
-
- surface_impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
hwnd = GDK_SURFACE_HWND (window);
if (gdk_surface_get_parent (window) == NULL)
{
ClientToScreen (hwnd, &point);
- point.x += _gdk_offset_x * surface_impl->surface_scale;
- point.y += _gdk_offset_y * surface_impl->surface_scale;
+ point.x += _gdk_offset_x * impl->surface_scale;
+ point.y += _gdk_offset_y * impl->surface_scale;
}
rect->left = point.x;
rect->right = point.x + client_rect.right - client_rect.left;
rect->bottom = point.y + client_rect.bottom - client_rect.top;
- return !surface_impl->inhibit_configure;
+ return !impl->inhibit_configure;
}
void
-_gdk_win32_do_emit_configure_event (GdkSurface *window,
+_gdk_win32_do_emit_configure_event (GdkSurface *surface,
RECT rect)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (surface);
impl->unscaled_width = rect.right - rect.left;
impl->unscaled_height = rect.bottom - rect.top;
- window->width = (impl->unscaled_width + impl->surface_scale - 1) / impl->surface_scale;
- window->height = (impl->unscaled_height + impl->surface_scale - 1) / impl->surface_scale;
- window->x = rect.left / impl->surface_scale;
- window->y = rect.top / impl->surface_scale;
+ surface->width = (impl->unscaled_width + impl->surface_scale - 1) / impl->surface_scale;
+ surface->height = (impl->unscaled_height + impl->surface_scale - 1) / impl->surface_scale;
+ surface->x = rect.left / impl->surface_scale;
+ surface->y = rect.top / impl->surface_scale;
- _gdk_surface_update_size (window);
+ _gdk_surface_update_size (surface);
- g_signal_emit_by_name (window, "size-changed", window->width, window->height);
+ g_signal_emit_by_name (surface, "size-changed", surface->width, surface->height);
}
void
-_gdk_win32_emit_configure_event (GdkSurface *window)
+_gdk_win32_emit_configure_event (GdkSurface *surface)
{
RECT rect;
- if (!_gdk_win32_get_window_rect (window, &rect))
+ if (!_gdk_win32_get_window_rect (surface, &rect))
return;
- _gdk_win32_do_emit_configure_event (window, rect);
+ _gdk_win32_do_emit_configure_event (surface, rect);
}
cairo_region_t *
HDC hdc;
PAINTSTRUCT paintstruct;
cairo_region_t *update_region;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
if (GetUpdateRgn (msg->hwnd, hrgn, FALSE) == ERROR)
{
gint *ret_valp)
{
RECT rect;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
if (window == NULL || window->input_shape == NULL)
return FALSE;
if (!GetWindowRect (hwnd, &rect))
return FALSE;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
rect.left = screen_x - rect.left;
rect.top = screen_y - rect.top;
handle_dpi_changed (GdkSurface *window,
MSG *msg)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
GdkDisplay *display = gdk_display_get_default ();
GdkWin32Display *win32_display = GDK_WIN32_DISPLAY (display);
RECT *rect = (RECT *)msg->lParam;
{
GdkEvent *event = gdk_event_new (type);
GdkDeviceManagerWin32 *device_manager;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
if (_gdk_input_ignore_core > 0)
return;
rover = GetNextWindow (rover, GW_HWNDNEXT))
{
GdkSurface *rover_gdkw = gdk_win32_handle_table_lookup (rover);
- GdkSurfaceImplWin32 *rover_impl;
+ GdkWin32Surface *rover_impl;
gboolean rover_ontop;
/* Checking window group not implemented yet */
continue;
rover_ontop = should_window_be_always_on_top (rover_gdkw);
- rover_impl = GDK_SURFACE_IMPL_WIN32 (rover_gdkw->impl);
+ rover_impl = GDK_WIN32_SURFACE (rover_gdkw);
if (GDK_SURFACE_IS_MAPPED (rover_gdkw) &&
(rover_impl->type_hint == GDK_SURFACE_TYPE_HINT_UTILITY ||
ensure_stacking_on_window_pos_changing (MSG *msg,
GdkSurface *window)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
WINDOWPOS *windowpos = (WINDOWPOS *) msg->lParam;
HWND rover;
gboolean restacking;
rover = GetNextWindow (rover, GW_HWNDNEXT))
{
GdkSurface *rover_gdkw = gdk_win32_handle_table_lookup (rover);
- GdkSurfaceImplWin32 *rover_impl;
+ GdkWin32Surface *rover_impl;
gboolean rover_ontop;
/* Checking window group not implemented yet */
continue;
rover_ontop = should_window_be_always_on_top (rover_gdkw);
- rover_impl = GDK_SURFACE_IMPL_WIN32 (rover_gdkw->impl);
+ rover_impl = GDK_WIN32_SURFACE (rover_gdkw);
if (GDK_SURFACE_IS_MAPPED (rover_gdkw) &&
(rover_impl->type_hint == GDK_SURFACE_TYPE_HINT_UTILITY ||
ensure_stacking_on_activate_app (MSG *msg,
GdkSurface *window)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
HWND rover;
gboolean window_ontop;
rover = GetNextWindow (rover, GW_HWNDPREV))
{
GdkSurface *rover_gdkw = gdk_win32_handle_table_lookup (rover);
- GdkSurfaceImplWin32 *rover_impl;
+ GdkWin32Surface *rover_impl;
gboolean rover_ontop;
/* Checking window group not implemented yet */
continue;
rover_ontop = should_window_be_always_on_top (rover_gdkw);
- rover_impl = GDK_SURFACE_IMPL_WIN32 (rover_gdkw->impl);
+ rover_impl = GDK_WIN32_SURFACE (rover_gdkw);
if (GDK_SURFACE_IS_MAPPED (rover_gdkw) &&
(rover_impl->type_hint == GDK_SURFACE_TYPE_HINT_UTILITY ||
static gboolean
handle_wm_sysmenu (GdkSurface *window, MSG *msg, gint *ret_valp)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
LONG_PTR style, tmp_style;
LONG_PTR additional_styles;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
style = GetWindowLongPtr (msg->hwnd, GWL_STYLE);
_gdk_win32_surface_fill_min_max_info (GdkSurface *window,
MINMAXINFO *mmi)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
RECT rect;
if (GDK_SURFACE_DESTROYED (window))
return FALSE;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->hint_flags & GDK_HINT_MIN_SIZE)
{
GdkDisplay *display;
GdkSurface *window = NULL;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
GdkWin32Display *win32_display;
GdkSurface *new_window;
#define return GOTO_DONE_INSTEAD
if (msg->message == aerosnap_message)
- _gdk_win32_surface_handle_aerosnap (gdk_surface_get_toplevel (window),
+ _gdk_win32_surface_handle_aerosnap (window,
(GdkWin32AeroSnapCombo) msg->wParam);
switch (msg->message)
if (GDK_SURFACE_DESTROYED (window))
break;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
API_CALL (GetKeyboardState, (key_state));
generate_button_event (GDK_BUTTON_RELEASE, button,
window, msg);
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
/* End a drag op when the same button that started it is released */
if (impl->drag_move_resize_context.op != GDK_WIN32_DRAGOP_NONE &&
if (!pointer_grab->owner_events &&
new_window != NULL &&
- new_window != pointer_grab->native_surface)
+ new_window != pointer_grab->surface)
new_window = NULL;
}
}
g_set_object (&window, find_window_for_mouse_event (window, msg));
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
/* If we haven't moved, don't create any GDK event. Windows
* sends WM_MOUSEMOVE messages after a new window is shows under
g_set_object (&window, new_window);
}
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
ScreenToClient (msg->hwnd, &point);
event = gdk_event_new (GDK_SCROLL);
return_val = TRUE;
}
- if (_gdk_modal_blocked (gdk_surface_get_toplevel (window)))
+ if (_gdk_modal_blocked (window))
{
*ret_valp = MA_NOACTIVATEANDEAT;
return_val = TRUE;
if (!return_val &&
!GDK_SURFACE_DESTROYED (window) &&
- GDK_SURFACE_IMPL_WIN32 (window->impl)->cursor != NULL)
+ GDK_WIN32_SURFACE (window)->cursor != NULL)
{
win32_display = GDK_WIN32_DISPLAY (gdk_surface_get_display (window));
- GDK_NOTE (EVENTS, g_print (" (window SetCursor(%p)", gdk_win32_hcursor_get_handle (GDK_SURFACE_IMPL_WIN32 (window->impl)->cursor)));
- SetCursor (gdk_win32_hcursor_get_handle (GDK_SURFACE_IMPL_WIN32 (window->impl)->cursor));
+ GDK_NOTE (EVENTS, g_print (" (window SetCursor(%p)", gdk_win32_hcursor_get_handle (GDK_WIN32_SURFACE (window)->cursor)));
+ SetCursor (gdk_win32_hcursor_get_handle (GDK_WIN32_SURFACE (window)->cursor));
return_val = TRUE;
*ret_valp = TRUE;
}
break;
case WM_INITMENU:
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->have_temp_styles)
{
do_show_window (window, msg->wParam == SC_MINIMIZE ? TRUE : FALSE);
break;
case SC_MAXIMIZE:
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
impl->maximizing = TRUE;
break;
}
_gdk_win32_end_modal_call (GDK_WIN32_MODAL_OP_SIZEMOVE_MASK);
}
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->drag_move_resize_context.op != GDK_WIN32_DRAGOP_NONE)
gdk_win32_surface_end_move_resize_drag (window);
{
return_val = ensure_stacking_on_window_pos_changing (msg, window);
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->maximizing)
{
!GDK_SURFACE_DESTROYED (window))
{
/* Make transient parent the forground window when window unmaps */
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->transient_owner &&
GetForegroundWindow () == GDK_SURFACE_HWND (window))
_gdk_win32_rect_to_string (&rect),
_gdk_win32_rect_to_string (drag)));
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
orig_drag = *drag;
if (impl->hint_flags & GDK_HINT_RESIZE_INC)
{
_gdk_win32_append_event (event);
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->transient_owner && GetForegroundWindow() == GDK_SURFACE_HWND (window))
{
#include <stdlib.h>
#include "gdk.h"
-#include "gdksurfaceimpl.h"
+#include "gdksurfaceprivate.h"
#include "gdkprivate-win32.h"
#include "gdkdeviceprivate.h"
#include "gdkdevicemanager-win32.h"
#include <math.h>
#include "fallback-c89.c"
-static void gdk_surface_impl_win32_init (GdkSurfaceImplWin32 *window);
-static void gdk_surface_impl_win32_class_init (GdkSurfaceImplWin32Class *klass);
-static void gdk_surface_impl_win32_finalize (GObject *object);
+static void gdk_surface_win32_finalize (GObject *object);
static gpointer parent_class = NULL;
static GSList *modal_window_stack = NULL;
static gboolean _gdk_surface_get_functions (GdkSurface *window,
GdkWMFunction *functions);
-struct _GdkWin32Surface {
- GdkSurface parent;
-};
-
-struct _GdkWin32SurfaceClass {
- GdkSurfaceClass parent_class;
-};
-
G_DEFINE_TYPE (GdkWin32Surface, gdk_win32_surface, GDK_TYPE_SURFACE)
static void
-gdk_win32_surface_class_init (GdkWin32SurfaceClass *window_class)
-{
-}
-
-static void
-gdk_win32_surface_init (GdkWin32Surface *window)
-{
-}
-
-
-G_DEFINE_TYPE (GdkSurfaceImplWin32, gdk_surface_impl_win32, GDK_TYPE_SURFACE_IMPL)
-
-GType
-_gdk_surface_impl_win32_get_type (void)
-{
- static GType object_type = 0;
-
- if (!object_type)
- {
- const GTypeInfo object_info =
- {
- sizeof (GdkSurfaceImplWin32Class),
- (GBaseInitFunc) NULL,
- (GBaseFinalizeFunc) NULL,
- (GClassInitFunc) gdk_surface_impl_win32_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GdkSurfaceImplWin32),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gdk_surface_impl_win32_init,
- };
-
- object_type = g_type_register_static (GDK_TYPE_SURFACE_IMPL,
- "GdkSurfaceImplWin32",
- &object_info, 0);
- }
-
- return object_type;
-}
-
-static void
-gdk_surface_impl_win32_init (GdkSurfaceImplWin32 *impl)
+gdk_win32_surface_init (GdkWin32Surface *impl)
{
impl->hicon_big = NULL;
impl->hicon_small = NULL;
static void
-gdk_surface_impl_win32_dispose (GObject *object)
+gdk_surface_win32_dispose (GObject *object)
{
- GdkSurfaceImplWin32 *surface_impl;
+ GdkWin32Surface *surface;
- g_return_if_fail (GDK_IS_SURFACE_IMPL_WIN32 (object));
+ g_return_if_fail (GDK_IS_WIN32_SURFACE (object));
- surface_impl = GDK_SURFACE_IMPL_WIN32 (object);
+ surface = GDK_WIN32_SURFACE (object);
- g_clear_object (&surface_impl->cursor);
+ g_clear_object (&surface->cursor);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
-gdk_surface_impl_win32_finalize (GObject *object)
+gdk_surface_win32_finalize (GObject *object)
{
GdkSurface *wrapper;
- GdkSurfaceImplWin32 *surface_impl;
+ GdkWin32Surface *surface;
- g_return_if_fail (GDK_IS_SURFACE_IMPL_WIN32 (object));
+ g_return_if_fail (GDK_IS_WIN32_SURFACE (object));
- surface_impl = GDK_SURFACE_IMPL_WIN32 (object);
+ surface = GDK_WIN32_SURFACE (object);
- wrapper = surface_impl->wrapper;
+ wrapper = surface->wrapper;
if (!GDK_SURFACE_DESTROYED (wrapper))
{
- gdk_win32_handle_table_remove (surface_impl->handle);
+ gdk_win32_handle_table_remove (surface->handle);
}
- g_clear_pointer (&surface_impl->snap_stash, g_free);
- g_clear_pointer (&surface_impl->snap_stash_int, g_free);
+ g_clear_pointer (&surface->snap_stash, g_free);
+ g_clear_pointer (&surface->snap_stash_int, g_free);
- if (surface_impl->hicon_big != NULL)
+ if (surface->hicon_big != NULL)
{
- GDI_CALL (DestroyIcon, (surface_impl->hicon_big));
- surface_impl->hicon_big = NULL;
+ GDI_CALL (DestroyIcon, (surface->hicon_big));
+ surface->hicon_big = NULL;
}
- if (surface_impl->hicon_small != NULL)
+ if (surface->hicon_small != NULL)
{
- GDI_CALL (DestroyIcon, (surface_impl->hicon_small));
- surface_impl->hicon_small = NULL;
+ GDI_CALL (DestroyIcon, (surface->hicon_small));
+ surface->hicon_small = NULL;
}
- g_free (surface_impl->decorations);
+ g_free (surface->decorations);
- if (surface_impl->cache_surface)
+ if (surface->cache_surface)
{
- cairo_surface_destroy (surface_impl->cache_surface);
- surface_impl->cache_surface = NULL;
+ cairo_surface_destroy (surface->cache_surface);
+ surface->cache_surface = NULL;
}
_gdk_win32_surface_unregister_dnd (wrapper);
- g_clear_object (&surface_impl->drop);
+ g_clear_object (&surface->drop);
- g_assert (surface_impl->transient_owner == NULL);
- g_assert (surface_impl->transient_children == NULL);
+ g_assert (surface->transient_owner == NULL);
+ g_assert (surface->transient_children == NULL);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
gboolean
_gdk_win32_surface_enable_transparency (GdkSurface *window)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
DWM_BLURBEHIND blur_behind;
HRGN empty_region;
HRESULT call_result;
if (window == NULL || GDK_SURFACE_HWND (window) == NULL)
return FALSE;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
/* layered windows don't need blurbehind for transparency */
if (impl->layered)
*
* [1] http://mail.gnome.org/archives/gtk-devel-list/2010-August/msg00214.html
*/
-void
-_gdk_win32_display_create_surface_impl (GdkDisplay *display,
- GdkSurface *window,
- GdkSurface *real_parent)
+GdkSurface *
+_gdk_win32_display_create_surface (GdkDisplay *display,
+ GdkSurfaceType surface_type,
+ GdkSurface *parent,
+ int x,
+ int y,
+ int width,
+ int height)
{
HWND hwndNew;
HANDLE hparent;
ATOM klass = 0;
DWORD dwStyle = 0, dwExStyle;
RECT rect;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
GdkWin32Display *display_win32;
const gchar *title;
wchar_t *wtitle;
gint window_width, window_height;
+ gint window_x, window_y;
gint offset_x = 0, offset_y = 0;
- gint x, y, real_x = 0, real_y = 0;
+ gint real_x = 0, real_y = 0;
GdkFrameClock *frame_clock;
- g_return_if_fail (display == _gdk_display);
+ g_return_val_if_fail (display == _gdk_display, NULL);
GDK_NOTE (MISC,
- g_print ("_gdk_surface_impl_new: %s\n", (window->surface_type == GDK_SURFACE_TOPLEVEL ? "TOPLEVEL" :
- (window->surface_type == GDK_SURFACE_TEMP ? "TEMP" : "???")));
+ g_print ("_gdk_surface_new: %s\n", (surface_type == GDK_SURFACE_TOPLEVEL ? "TOPLEVEL" :
+ (surface_type == GDK_SURFACE_TEMP ? "TEMP" : "???"))));
- hparent = (real_parent != NULL) ? GDK_SURFACE_HWND (real_parent) : NULL;
+ hparent = (parent != NULL) ? GDK_SURFACE_HWND (parent) : NULL;
- impl = g_object_new (GDK_TYPE_SURFACE_IMPL_WIN32, NULL);
- impl->wrapper = GDK_SURFACE (window);
- window->impl = GDK_SURFACE_IMPL (impl);
+ impl = g_object_new (GDK_TYPE_WIN32_SURFACE, NULL);
impl->layered = FALSE;
impl->layered_opacity = 1.0;
display_win32 = GDK_WIN32_DISPLAY (display);
impl->surface_scale = _gdk_win32_display_get_monitor_scale_factor (display_win32, NULL, NULL, NULL);
- impl->unscaled_width = window->width * impl->surface_scale;
- impl->unscaled_height = window->height * impl->surface_scale;
+ impl->unscaled_width = width * impl->surface_scale;
+ impl->unscaled_height = height * impl->surface_scale;
dwExStyle = 0;
- switch (window->surface_type)
+ switch (surface_type)
{
case GDK_SURFACE_TOPLEVEL:
- if (window->parent)
+ if (parent)
{
/* The common code warns for this case. */
hparent = GetDesktopWindow ();
}
/* MSDN: We need WS_CLIPCHILDREN and WS_CLIPSIBLINGS for GL Context Creation */
- if (window->surface_type == GDK_SURFACE_TOPLEVEL)
+ if (surface_type == GDK_SURFACE_TOPLEVEL)
dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
else
dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME | WS_CLIPCHILDREN;
offset_y = _gdk_offset_y;
break;
+ case GDK_SURFACE_POPUP:
case GDK_SURFACE_TEMP:
/* A temp window is not necessarily a top level window */
- dwStyle = real_parent == NULL ? WS_POPUP : WS_CHILDWINDOW;
+ dwStyle = parent == NULL ? WS_POPUP : WS_CHILDWINDOW;
dwStyle |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
dwExStyle |= WS_EX_TOOLWINDOW | WS_EX_TOPMOST;
offset_x = _gdk_offset_x;
offset_y = _gdk_offset_y;
break;
-
default:
g_assert_not_reached ();
}
- rect.left = window->x * impl->surface_scale;
- rect.top = window->y * impl->surface_scale;
- rect.right = rect.left + window->width * impl->surface_scale;
- rect.bottom = rect.top + window->height * impl->surface_scale;
+ rect.left = x * impl->surface_scale;
+ rect.top = y * impl->surface_scale;
+ rect.right = rect.left + width * impl->surface_scale;
+ rect.bottom = rect.top + height * impl->surface_scale;
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
- real_x = (window->x - offset_x) * impl->surface_scale;
- real_y = (window->y - offset_y) * impl->surface_scale;
+ real_x = (x - offset_x) * impl->surface_scale;
+ real_y = (y - offset_y) * impl->surface_scale;
- if (window->surface_type == GDK_SURFACE_TOPLEVEL)
+ if (surface_type == GDK_SURFACE_TOPLEVEL)
{
/* We initially place it at default so that we can get the
default window positioning if we want */
- x = y = CW_USEDEFAULT;
+ window_x = window_y = CW_USEDEFAULT;
}
else
{
/* TEMP: Put these where requested */
- x = real_x;
- y = real_y;
+ window_x = real_x;
+ window_y = real_y;
}
window_width = rect.right - rect.left;
if (impl->type_hint == GDK_SURFACE_TYPE_HINT_DND)
dwExStyle |= WS_EX_TRANSPARENT;
- klass = RegisterGdkClass (window->surface_type, impl->type_hint);
+ klass = RegisterGdkClass (surface_type, impl->type_hint);
wtitle = g_utf8_to_utf16 (title, -1, NULL, NULL, NULL);
MAKEINTRESOURCEW (klass),
wtitle,
dwStyle,
- x,
- y,
+ window_x, window_y,
window_width, window_height,
hparent,
NULL,
_gdk_dll_hinstance,
- window);
- if (GDK_SURFACE_HWND (window) != hwndNew)
- {
- g_warning ("gdk_surface_new: gdk_event_translate::WM_CREATE (%p, %p) HWND mismatch.",
- GDK_SURFACE_HWND (window),
- hwndNew);
-
- /* HB: IHMO due to a race condition the handle was increased by
- * one, which causes much trouble. Because I can't find the
- * real bug, try to workaround it ...
- * To reproduce: compile with MSVC 5, DEBUG=1
- */
-# if 0
- gdk_win32_handle_table_remove (GDK_SURFACE_HWND (window));
- GDK_SURFACE_HWND (window) = hwndNew;
- gdk_win32_handle_table_insert (&GDK_SURFACE_HWND (window), window);
-# else
- /* the old behaviour, but with warning */
- impl->handle = hwndNew;
-# endif
-
- }
+ NULL);
+ impl->handle = hwndNew;
- GetWindowRect (GDK_SURFACE_HWND (window), &rect);
+ GetWindowRect (hwndNew, &rect);
impl->initial_x = rect.left;
impl->initial_y = rect.top;
/* Now we know the initial position, move to actually specified position */
- if (real_x != x || real_y != y)
+ if (real_x != window_x || real_y != window_y)
{
- API_CALL (SetWindowPos, (GDK_SURFACE_HWND (window),
+ API_CALL (SetWindowPos, (hwndNew,
SWP_NOZORDER_SPECIFIED,
real_x, real_y, 0, 0,
SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER));
}
- g_object_ref (window);
- gdk_win32_handle_table_insert (&GDK_SURFACE_HWND (window), window);
+ g_object_ref (impl);
+ gdk_win32_handle_table_insert (&hwndNew, impl);
GDK_NOTE (MISC, g_print ("... \"%s\" %dx%d@%+d%+d %p = %p\n",
title,
window_width, window_height,
- window->x - offset_x,
- window->y - offset_y,
+ GDK_SURFACE (impl)->x - offset_x,
+ GDK_SURFACE (impl)->y - offset_y,
hparent,
- GDK_SURFACE_HWND (window)));
-
- /* Add window handle to title */
- GDK_NOTE (MISC_OR_EVENTS, gdk_surface_set_title (window, title));
+ hwndNew));
g_free (wtitle);
if (impl->handle == NULL)
{
WIN32_API_FAILED ("CreateWindowExW");
- g_object_unref (window);
- return;
+ g_object_unref (impl);
+ return NULL;
}
- _gdk_win32_surface_enable_transparency (window);
+ _gdk_win32_surface_enable_transparency (GDK_SURFACE (impl));
- frame_clock = gdk_surface_get_frame_clock (window);
+ frame_clock = gdk_surface_get_frame_clock (GDK_SURFACE (impl));
g_signal_connect (frame_clock,
"after-paint",
G_CALLBACK (gdk_win32_impl_frame_clock_after_paint),
- window);
+ impl);
+
+ return GDK_SURFACE (impl);
}
static void
gdk_win32_surface_destroy (GdkSurface *window,
- gboolean recursing,
- gboolean foreign_destroy)
+ gboolean foreign_destroy)
{
- GdkSurfaceImplWin32 *surface_impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *surface = GDK_WIN32_SURFACE (window);
g_return_if_fail (GDK_IS_SURFACE (window));
_gdk_remove_modal_window (window);
/* Remove all our transient children */
- while (surface_impl->transient_children != NULL)
+ while (surface->transient_children != NULL)
{
- GdkSurface *child = surface_impl->transient_children->data;
+ GdkSurface *child = surface->transient_children->data;
gdk_surface_set_transient_for (child, NULL);
}
/* Remove ourself from our transient owner */
- if (surface_impl->transient_owner != NULL)
+ if (surface->transient_owner != NULL)
{
gdk_surface_set_transient_for (window, NULL);
}
- if (!recursing && !foreign_destroy)
+ if (!foreign_destroy)
{
window->destroyed = TRUE;
DestroyWindow (GDK_SURFACE_HWND (window));
gint height,
RECT *rect)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
rect->left = rect->top = 0;
rect->right = width * impl->surface_scale;
gint *x,
gint *y)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
if (impl->hint_flags & GDK_HINT_WIN_GRAVITY)
{
gboolean already_mapped,
gboolean deiconify)
{
- GdkSurfaceImplWin32 *surface_impl;
+ GdkWin32Surface *surface;
gboolean focus_on_map = FALSE;
DWORD exstyle;
* + Certain window types and hints have more elaborate positioning
* schemes.
*/
- surface_impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ surface = GDK_WIN32_SURFACE (window);
if (!already_mapped &&
GDK_SURFACE_TYPE (window) == GDK_SURFACE_TOPLEVEL &&
- (surface_impl->hint_flags & (GDK_HINT_POS | GDK_HINT_USER_POS)) == 0)
+ (surface->hint_flags & (GDK_HINT_POS | GDK_HINT_USER_POS)) == 0)
{
gboolean center = FALSE;
RECT window_rect, center_on_rect;
int x, y;
- x = surface_impl->initial_x;
- y = surface_impl->initial_y;
+ x = surface->initial_x;
+ y = surface->initial_y;
- if (surface_impl->type_hint == GDK_SURFACE_TYPE_HINT_SPLASHSCREEN)
+ if (surface->type_hint == GDK_SURFACE_TYPE_HINT_SPLASHSCREEN)
{
HMONITOR monitor;
MONITORINFO mi;
}
center = TRUE;
}
- else if (surface_impl->transient_owner != NULL &&
- GDK_SURFACE_IS_MAPPED (surface_impl->transient_owner))
+ else if (surface->transient_owner != NULL &&
+ GDK_SURFACE_IS_MAPPED (surface->transient_owner))
{
- GdkSurface *owner = surface_impl->transient_owner;
+ GdkSurface *owner = surface->transient_owner;
/* Center on transient parent */
- center_on_rect.left = (owner->x - _gdk_offset_x) * surface_impl->surface_scale;
- center_on_rect.top = (owner->y - _gdk_offset_y) * surface_impl->surface_scale;
- center_on_rect.right = center_on_rect.left + owner->width * surface_impl->surface_scale;
- center_on_rect.bottom = center_on_rect.top + owner->height * surface_impl->surface_scale;
+ center_on_rect.left = (owner->x - _gdk_offset_x) * surface->surface_scale;
+ center_on_rect.top = (owner->y - _gdk_offset_y) * surface->surface_scale;
+ center_on_rect.right = center_on_rect.left + owner->width * surface->surface_scale;
+ center_on_rect.bottom = center_on_rect.top + owner->height * surface->surface_scale;
_gdk_win32_adjust_client_rect (GDK_SURFACE (owner), ¢er_on_rect);
center = TRUE;
{
window_rect.left = 0;
window_rect.top = 0;
- window_rect.right = window->width * surface_impl->surface_scale;
- window_rect.bottom = window->height * surface_impl->surface_scale;
+ window_rect.right = window->width * surface->surface_scale;
+ window_rect.bottom = window->height * surface->surface_scale;
_gdk_win32_adjust_client_rect (window, &window_rect);
x = center_on_rect.left + ((center_on_rect.right - center_on_rect.left) - (window_rect.right - window_rect.left)) / 2;
else
{
RECT outer_rect;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
get_outer_rect (window, window->width, window->height, &outer_rect);
else
{
RECT outer_rect;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
get_outer_rect (window, width, height, &outer_rect);
gint width,
gint height)
{
- GdkSurfaceImplWin32 *surface_impl;
+ GdkWin32Surface *surface = GDK_WIN32_SURFACE (window);
- surface_impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
- surface_impl->inhibit_configure = TRUE;
+ surface->inhibit_configure = TRUE;
/* We ignore changes to the window being moved or resized by the
user, as we don't want to fight the user */
}
out:
- surface_impl->inhibit_configure = FALSE;
+ surface->inhibit_configure = FALSE;
_gdk_win32_emit_configure_event (window);
}
get_effective_window_decorations (GdkSurface *window,
GdkWMDecoration *decoration)
{
- GdkSurfaceImplWin32 *impl;
-
- impl = (GdkSurfaceImplWin32 *)window->impl;
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
if (gdk_surface_get_decorations (window, decoration))
return TRUE;
const GdkGeometry *geometry,
GdkSurfaceHints geom_mask)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
FullscreenInfo *fi;
g_return_if_fail (GDK_IS_SURFACE (window));
GDK_NOTE (MISC, g_print ("gdk_surface_set_geometry_hints: %p\n",
GDK_SURFACE_HWND (window)));
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
-
fi = g_object_get_data (G_OBJECT (window), "fullscreen-info");
if (fi)
fi->hint_flags = geom_mask;
HWND window_id, parent_id;
LONG_PTR old_ptr;
DWORD w32_error;
- GdkSurfaceImplWin32 *surface_impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
- GdkSurfaceImplWin32 *parent_impl = NULL;
+ GdkWin32Surface *surface = GDK_WIN32_SURFACE (window);
+ GdkWin32Surface *parent_impl = NULL;
GSList *item;
g_return_if_fail (GDK_IS_SURFACE (window));
return;
}
- if (surface_impl->transient_owner == parent)
+ if (surface->transient_owner == parent)
return;
- if (GDK_IS_SURFACE (surface_impl->transient_owner))
+ if (GDK_IS_SURFACE (surface->transient_owner))
{
- GdkSurfaceImplWin32 *trans_impl = GDK_SURFACE_IMPL_WIN32 (surface_impl->transient_owner->impl);
+ GdkWin32Surface *trans_impl = GDK_WIN32_SURFACE (surface->transient_owner);
item = g_slist_find (trans_impl->transient_children, window);
item->data = NULL;
trans_impl->transient_children = g_slist_delete_link (trans_impl->transient_children, item);
trans_impl->transient_children = NULL;
}
- g_object_unref (G_OBJECT (surface_impl->transient_owner));
+ g_object_unref (G_OBJECT (surface->transient_owner));
g_object_unref (G_OBJECT (window));
- surface_impl->transient_owner = NULL;
+ surface->transient_owner = NULL;
}
if (parent)
{
- parent_impl = GDK_SURFACE_IMPL_WIN32 (parent->impl);
+ parent_impl = GDK_WIN32_SURFACE (parent);
parent_impl->transient_children = g_slist_append (parent_impl->transient_children, window);
g_object_ref (G_OBJECT (window));
parent_impl->num_transients++;
- surface_impl->transient_owner = parent;
+ surface->transient_owner = parent;
g_object_ref (G_OBJECT (parent));
}
void
_gdk_push_modal_window (GdkSurface *window)
{
- modal_window_stack = g_slist_prepend (modal_window_stack,
- window);
+ modal_window_stack = g_slist_prepend (modal_window_stack, window);
}
void
if (!GDK_SURFACE_DESTROYED (window))
{
RECT rect;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
API_CALL (GetClientRect, (GDK_SURFACE_HWND (window), &rect));
gint tx;
gint ty;
POINT pt;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
pt.x = x * impl->surface_scale;
pt.y = y * impl->surface_scale;
{
HWND hwnd;
RECT r;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
g_return_if_fail (GDK_IS_SURFACE (window));
g_return_if_fail (rect != NULL);
while (window->parent && window->parent->parent)
window = window->parent;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
hwnd = GDK_SURFACE_HWND (window);
API_CALL (GetWindowRect, (hwnd, &r));
gint w, h;
gint dw, dh, diff;
HICON small_hicon, big_hicon;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
g_return_if_fail (GDK_IS_SURFACE (window));
if (GDK_SURFACE_DESTROYED (window) || textures == NULL)
return;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
/* ideal sizes for small and large icons */
big_w = GetSystemMetrics (SM_CXICON);
gboolean
_gdk_win32_surface_lacks_wm_decorations (GdkSurface *window)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
LONG style;
gboolean has_any_decorations;
if (GDK_SURFACE_DESTROYED (window))
return FALSE;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
/* This is because GTK calls gdk_surface_set_decorations (window, 0),
* even though GdkWMDecoration docs indicate that 0 does NOT mean
void
_gdk_win32_surface_update_style_bits (GdkSurface *window)
{
- GdkSurfaceImplWin32 *impl = (GdkSurfaceImplWin32 *)window->impl;
+ GdkWin32Surface *impl = (GdkWin32Surface *)window;
GdkWMDecoration decorations;
LONG old_style, new_style, old_exstyle, new_exstyle;
gboolean all;
gdk_win32_surface_set_decorations (GdkSurface *window,
GdkWMDecoration decorations)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
g_return_if_fail (GDK_IS_SURFACE (window));
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
GDK_NOTE (MISC, g_print ("gdk_surface_set_decorations: %p: %s %s%s%s%s%s%s\n",
GDK_SURFACE_HWND (window),
gdk_win32_surface_get_decorations (GdkSurface *window,
GdkWMDecoration *decorations)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
g_return_val_if_fail (GDK_IS_SURFACE (window), FALSE);
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->decorations == NULL)
return FALSE;
{
GdkDisplay *display;
gint n_monitors, monitor_idx, other_monitor_idx;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (context->window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (context->window);
#if defined(MORE_AEROSNAP_DEBUGGING)
gint i;
#endif
static void
discard_snapinfo (GdkSurface *window)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
impl->snap_state = GDK_WIN32_AEROSNAP_STATE_UNDETERMINED;
unsnap (GdkSurface *window,
GdkMonitor *monitor)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
GdkRectangle rect;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
impl->snap_state = GDK_WIN32_AEROSNAP_STATE_UNDETERMINED;
static void
stash_window (GdkSurface *window,
- GdkSurfaceImplWin32 *impl)
+ GdkWin32Surface *impl)
{
gint x, y;
gint width, wwidth;
SHORT maxysize;
gint x, y;
gint width, height;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
impl->snap_state = GDK_WIN32_AEROSNAP_STATE_FULLUP;
GdkMonitor *snap_monitor)
{
GdkRectangle rect;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
impl->snap_state = GDK_WIN32_AEROSNAP_STATE_HALFLEFT;
GdkMonitor *snap_monitor)
{
GdkRectangle rect;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
impl->snap_state = GDK_WIN32_AEROSNAP_STATE_HALFRIGHT;
_gdk_win32_surface_handle_aerosnap (GdkSurface *window,
GdkWin32AeroSnapCombo combo)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
GdkDisplay *display;
gint n_monitors;
GdkSurfaceState surface_state = gdk_surface_get_state (window);
gboolean halfsnapped;
GdkMonitor *monitor;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
display = gdk_surface_get_display (window);
n_monitors = gdk_display_get_n_monitors (display);
monitor = gdk_display_get_monitor_at_surface (display, window);
gdouble line_width;
gdouble corner_radius;
gint64 animation_duration;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (context->window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (context->window);
line_width = AEROSNAP_INDICATOR_LINE_WIDTH * impl->surface_scale;
corner_radius = AEROSNAP_INDICATOR_CORNER_RADIUS;
POINT source_point = { 0, 0 };
gboolean last_draw;
gdouble indicator_opacity;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
gboolean do_source_remove = FALSE;
indicator_opacity = AEROSNAP_INDICATOR_OPACITY;
do_source_remove = TRUE;
}
- impl = GDK_SURFACE_IMPL_WIN32 (context->window->impl);
+ impl = GDK_WIN32_SURFACE (context->window);
if (!ensure_snap_indicator_surface (context,
context->indicator_window_rect.width,
SHORT maxysize;
GdkRectangle from, to;
GdkRectangle to_adjusted, from_adjusted, from_or_to;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
GDK_NOTE (MISC, g_print ("Update fullup indicator\n"));
if (context->shape_indicator == NULL)
return;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
maxysize = GetSystemMetrics (SM_CYVIRTUALSCREEN);
gdk_surface_get_position (window, &to.x, &to.y);
to.width = gdk_surface_get_width (window);
SHORT maxysize;
GdkRectangle start_size, end_size;
GdkDisplay *display;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
display = gdk_surface_get_display (window);
monitor = gdk_display_get_monitor_at_point (display, x, y);
return NULL;
}
-static gboolean
-point_in_window (GdkSurface *window,
- gdouble x,
- gdouble y)
-{
- return x >= 0 && x < window->width &&
- y >= 0 && y < window->height &&
- (window->input_shape == NULL ||
- cairo_region_contains_point (window->input_shape, x, y));
-}
-
-static GdkSurface *
-child_window_at_coordinates (GdkSurface *window,
- gint root_x,
- gint root_y)
-{
- gint x, y;
- GList *l;
- GList *children;
-
- children = gdk_surface_peek_children (window);
- gdk_surface_get_root_origin (window, &x, &y);
- x = root_x - x;
- y = root_y - y;
-
- for (l = children; l; l = g_list_next (l))
- {
- GdkSurface *child = GDK_SURFACE (l->data);
-
- if (point_in_window (child, x, y))
- return child;
- }
-
- return window;
-}
-
static void
setup_drag_move_resize_context (GdkSurface *window,
GdkW32DragMoveResizeContext *context,
RECT rect;
const gchar *cursor_name;
GdkSurface *pointer_window;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
gboolean maximized = gdk_surface_get_state (window) & GDK_SURFACE_STATE_MAXIMIZED;
gint root_x, root_y;
context->cursor = gdk_cursor_new_from_name (cursor_name, NULL);
- pointer_window = child_window_at_coordinates (window, root_x, root_y);
+ pointer_window = window;
/* Note: This triggers a WM_CAPTURECHANGED, which will trigger
* gdk_win32_surface_end_move_resize_drag(), which will end
g_print ("begin drag moveresize: window %p, toplevel %p, "
"op %u, edge %d, device %p, "
"button %d, coord %d:%d, time %u\n",
- pointer_window, gdk_surface_get_toplevel (window),
+ pointer_window, window,
context->op, context->edge, context->device,
context->button, context->start_root_x,
context->start_root_y, context->timestamp));
void
gdk_win32_surface_end_move_resize_drag (GdkSurface *window)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
GdkW32DragMoveResizeContext *context = &impl->drag_move_resize_context;
context->op = GDK_WIN32_DRAGOP_NONE;
g_print ("end drag moveresize: window %p, toplevel %p,"
"op %u, edge %d, device %p, "
"button %d, coord %d:%d, time %u\n",
- window, gdk_surface_get_toplevel (window),
+ window, window,
context->op, context->edge, context->device,
context->button, context->start_root_x,
context->start_root_y, context->timestamp));
SIZE *window_size,
POINT *window_position)
{
- GdkSurfaceImplWin32 *impl;
-
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
/* Turn client area into window area */
_gdk_win32_adjust_client_rect (window, window_rect);
SIZE *window_size_ptr;
POINT source_point = { 0, 0 };
POINT *source_point_ptr;
- GdkSurfaceImplWin32 *impl;
-
- impl = GDK_SURFACE_IMPL_WIN32 (surface->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (surface);
gdk_win32_get_window_size_and_position_from_client_rect (surface,
client_rect,
RECT new_rect;
gint diffy, diffx;
MINMAXINFO mmi;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
GdkW32DragMoveResizeContext *context;
gint width;
gint height;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
context = &impl->drag_move_resize_context;
if (!_gdk_win32_get_window_rect (window, &rect))
gint y,
guint32 timestamp)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
g_return_if_fail (GDK_IS_SURFACE (window));
if (button != 1)
return;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->drag_move_resize_context.op != GDK_WIN32_DRAGOP_NONE)
gdk_win32_surface_end_move_resize_drag (window);
gint y,
guint32 timestamp)
{
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
g_return_if_fail (GDK_IS_SURFACE (window));
if (button != 1)
return;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->drag_move_resize_context.op != GDK_WIN32_DRAGOP_NONE)
gdk_win32_surface_end_move_resize_drag (window);
g_free (fi);
else
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
monitor = MonitorFromWindow (GDK_SURFACE_HWND (window), MONITOR_DEFAULTTONEAREST);
mi.cbSize = sizeof (mi);
fi = g_object_get_data (G_OBJECT (window), "fullscreen-info");
if (fi)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_FULLSCREEN, 0);
g_enum_get_value (class, hint)->value_name);
}G_STMT_END);
- ((GdkSurfaceImplWin32 *)window->impl)->type_hint = hint;
+ GDK_WIN32_SURFACE (window)->type_hint = hint;
_gdk_win32_surface_update_style_bits (window);
}
if (GDK_SURFACE_DESTROYED (window))
return GDK_SURFACE_TYPE_HINT_NORMAL;
- return GDK_SURFACE_IMPL_WIN32 (window->impl)->type_hint;
+ return GDK_WIN32_SURFACE (window)->type_hint;
}
GdkSurface *
LONG exstyle;
typedef BOOL (WINAPI *PFN_SetLayeredWindowAttributes) (HWND, COLORREF, BYTE, DWORD);
PFN_SetLayeredWindowAttributes setLayeredWindowAttributes = NULL;
- GdkSurfaceImplWin32 *impl;
+ GdkWin32Surface *impl;
g_return_if_fail (GDK_IS_SURFACE (window));
else if (opacity > 1)
opacity = 1;
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
if (impl->layered)
{
gboolean
gdk_win32_surface_is_win32 (GdkSurface *window)
{
- return GDK_SURFACE_IS_WIN32 (window);
+ return GDK_IS_WIN32_SURFACE (window);
}
static gboolean
{
double event_x, event_y;
gint x, y;
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
switch (event->any.type)
{
HWND
gdk_win32_surface_get_impl_hwnd (GdkSurface *window)
{
- if (GDK_SURFACE_IS_WIN32 (window))
+ if (GDK_IS_WIN32_SURFACE (window))
return GDK_SURFACE_HWND (window);
return NULL;
}
BLENDFUNCTION blender;
HWND hwnd = GDK_SURFACE_HWND (window);
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
switch (cmd_show)
{
gint top,
gint bottom)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
if (GDK_SURFACE_DESTROYED (window))
return;
_gdk_win32_surface_get_scale_factor (GdkSurface *window)
{
GdkDisplay *display;
- GdkSurfaceImplWin32 *impl;
-
+ GdkWin32Surface *impl;
GdkWin32Display *win32_display;
if (GDK_SURFACE_DESTROYED (window))
g_return_val_if_fail (window != NULL, 1);
display = gdk_surface_get_display (window);
- impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ impl = GDK_WIN32_SURFACE (window);
win32_display = GDK_WIN32_DISPLAY (display);
gint *unscaled_width,
gint *unscaled_height)
{
- GdkSurfaceImplWin32 *impl = GDK_SURFACE_IMPL_WIN32 (window->impl);
+ GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
if (unscaled_width)
*unscaled_width = impl->unscaled_width;
}
static void
-gdk_surface_impl_win32_class_init (GdkSurfaceImplWin32Class *klass)
+gdk_win32_surface_class_init (GdkWin32SurfaceClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkSurfaceImplClass *impl_class = GDK_SURFACE_IMPL_CLASS (klass);
+ GdkSurfaceClass *impl_class = GDK_SURFACE_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
- object_class->dispose = gdk_surface_impl_win32_dispose;
- object_class->finalize = gdk_surface_impl_win32_finalize;
+ object_class->dispose = gdk_surface_win32_dispose;
+ object_class->finalize = gdk_surface_win32_finalize;
impl_class->show = gdk_win32_surface_show;
impl_class->hide = gdk_win32_surface_hide;
HGDIOBJ
gdk_win32_surface_get_handle (GdkSurface *window)
{
- if (!GDK_SURFACE_IS_WIN32 (window))
+ if (!GDK_IS_WIN32_SURFACE (window))
{
g_warning (G_STRLOC " window is not a native Win32 window");
return NULL;
projects / gtk4.git / commitdiff